package main

import (
	"fmt"
	"reflect"
)

/*
有 k 个服务器，编号为 0 到 k-1 ，它们可以同时处理多个请求组。每个服务器有无穷的计算能力但是 不能同时处理超过一个请求 。请求分配到服务器的规则如下：

第 i （序号从 0 开始）个请求到达。
如果所有服务器都已被占据，那么该请求被舍弃（完全不处理）。
如果第 (i % k) 个服务器空闲，那么对应服务器会处理该请求。
否则，将请求安排给下一个空闲的服务器（服务器构成一个环，必要的话可能从第 0 个服务器开始继续找下一个空闲的服务器）。比方说，如果第 i 个服务器在忙，那么会查看第 (i+1) 个服务器，第 (i+2) 个服务器等等。
给你一个 严格递增 的正整数数组 arrival ，表示第 i 个任务的到达时间，和另一个数组 load ，其中 load[i] 表示第 i 个请求的工作量（也就是服务器完成它所需要的时间）。你的任务是找到 最繁忙的服务器 。最繁忙定义为一个服务器处理的请求数是所有服务器里最多的。

请你返回包含所有 最繁忙服务器 序号的列表，你可以以任意顺序返回这个列表。

*/
func busiestServers(k int, arrival []int, load []int) []int {
	type server struct {
		work  int
		count int
	}
	max, re := 0, []int{}
	var servers []server
	for i := 0; i < k; i++ {
		servers = append(servers, server{})
	}

	arrivalStep := 0
	for step := 0; step <= arrival[len(arrival)-1]-1; step++ {
		if !(step+1 == arrival[arrivalStep]) {
			goto STEP
		}

		for i := arrivalStep % k; i < arrivalStep%k+k; i++ {

			if servers[i%k].work == 0 {
				servers[i%k].work = load[arrivalStep]
				servers[i%k].count++
				if max < servers[i%k].count {
					max = servers[i%k].count
				}
				break
			}
		}

		arrivalStep++

	STEP:
		for i := range servers {
			if servers[i].work > 0 {
				servers[i].work--
			}
		}
	}

	for i := range servers {
		if servers[i].count == max {
			re = append(re, i)
		}
	}

	return re
}

// 输入：k = 3, arrival = [1,2,3,4,5], load = [5,2,3,3,3]  输出：[1]
func test1() {
	k := 3
	arrival := []int{1, 2, 3, 4, 5}
	load := []int{5, 2, 3, 3, 3}
	input := []int{1}
	fmt.Println("1:", reflect.DeepEqual(input, busiestServers(k, arrival, load)))
}

// 输入：k = 3, arrival = [1,2,3,4], load = [1,2,1,2] 输出：[0]
func test2() {
	k := 3
	arrival := []int{1, 2, 3, 4}
	load := []int{1, 2, 1, 2}
	input := []int{0}
	fmt.Println("2:", reflect.DeepEqual(input, busiestServers(k, arrival, load)))
}

//输入：k = 3, arrival = [1,2,3], load = [10,12,11] 输出[0,1,2]
func test3() {
	k := 3
	arrival := []int{1, 2, 3}
	load := []int{10, 12, 11}
	input := []int{0, 1, 2}
	fmt.Println("3:", reflect.DeepEqual(input, busiestServers(k, arrival, load)))
}

// 输入：k = 3, arrival = [1,2,3,4,8,9,10], load = [5,2,10,3,1,2,2]  输出：[1]
func test4() {
	k := 3
	arrival := []int{1, 2, 3, 4, 8, 9, 10}
	load := []int{5, 2, 10, 3, 1, 2, 2}
	input := []int{1}
	fmt.Println("4:", reflect.DeepEqual(input, busiestServers(k, arrival, load)))
}

//输入：k = 1, arrival = [1], load = [1]  输出：[0]
func test5() {
	k := 1
	arrival := []int{1}
	load := []int{1}
	input := []int{0}
	fmt.Println("5:", reflect.DeepEqual(input, busiestServers(k, arrival, load)))
}

func main() {
	test1()
	test2()
	test3()
	test4()
	test5()
}
